home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 November: Tool Chest / Dev.CD Nov 98 TC.toast / Sample Code / Snippets / Toolbox / Prefs / Source / Pref.c
Encoding:
Text File  |  1996-09-17  |  16.9 KB  |  563 lines  |  [TEXT/CWIE]
  1. /* Sample System 7 Preferences */
  2.  
  3. /* Apple Developer Technical Support */
  4. /* Greg Robbins                      */
  5.  
  6. /* This application displays a sample preferences dialog
  7.    containing edit text, radio buttons, and a file selection,
  8.    and demonstrates storage of those items in a preferences
  9.    file.
  10.    
  11.    Requires System 7, though most elements (like resource use and
  12.    FindFolder calls) apply to System 6 also.                       */
  13.    
  14. /* Thanks to Godfrey DiGiorgi for advice & assistance. */
  15.  
  16. /* Rev 1.0   7/92 */
  17.  
  18. /* Thanks to Godfrey DiGiorgi for assistance */
  19.  
  20. //updates 8/96: line 166, NewModalFilterProc added; old routine names changed;
  21. //included <Processes.h>; Prefix.h added as prefix file for 68K and PPC MC projects
  22.  
  23. #ifdef THINK_C
  24.     #include <MacHeaders>
  25. #else
  26.     #include <QuickDraw.h>
  27.     #include <Fonts.h>
  28.     #include <GestaltEqu.h>
  29.     #include <Files.h>
  30.     #include <Resources.h>
  31.     #include <Dialogs.h>
  32.     #include <Menus.h>
  33.     #include <TextEdit.h>
  34.     #include <Windows.h>
  35.     #include <Controls.h>
  36.     #include <Folders.h>
  37.     #include <Errors.h>
  38.     #include <OSUtils.h>
  39.     #include <ToolUtils.h>
  40.     #include <Types.h>
  41.     #include <Memory.h>
  42.     #include <StandardFile.h>
  43.     #include <Aliases.h>
  44.     #include <Processes.h>
  45. #endif
  46.  
  47. /* preferences dialog ID and items */
  48.  
  49. #define kPrefsDialogID 128
  50. #define kSaveButtonItem 1
  51. #define kCancelButtonItem 2
  52. #define kHighRButtonItem 3
  53. #define kMediumRButtonItem 4
  54. #define kLowRButtonItem 5
  55. #define kSelectButtonItem 6
  56. #define kSelectStatTextItem 7
  57. #define kEditTextItem 8
  58.  
  59. /* prefs file constants */
  60. #define kPrefsNameStrID 128         /* name of prefs file */
  61. #define kPrefsCreatorType '????'
  62. #define kPrefsFileType 'pref'
  63. #define kPrefsResourceType 'Pref'
  64. #define kPrefsResourceID 128
  65. #define kFileAliasResourceID 128    /* resource ID of alias of preferred file */
  66.  
  67. /* misc dialog resource IDs */
  68. #define kGeneralAlertID 129
  69. #define kIntroAlertID 130
  70. #define kErrorStrListID 129        /* STR saying System 7 is required */
  71. #define kSystem7NeededStrIndex 1
  72.  
  73. #define kFinderMessageStrID -16397 /* ID of STR for default finder message */
  74.                                    /* see Inside Mac VI, page 9-22         */
  75. #define kStrType 'STR '
  76.  
  77.  
  78. /* this structure will contain the prefs for the application */
  79. typedef struct {
  80.     long prefsTypeVers;  /* version number of prefs struct                */
  81.     short rButtonShort;  /* radio button number                           */
  82.     short fileAliasID;   /* resource ID for saving alias of selected file */
  83.     Str255 editStr;      /* string from edit text box                     */
  84. } PrefsType;
  85.  
  86. /* these constants may be stored in the fields of the prefs struct */
  87. #define kCurrentPrefsTypeVers 1
  88. #define kNoAliasResourceID -1
  89.  
  90. /* function prototypes */
  91.  
  92. void main (void);
  93. short OpenPrefsResFile(SignedByte prefsPerm, Boolean createFlag);
  94. Boolean DoPrefsDialog(PrefsType * thePrefsType, AliasHandle * fileAliasHandlePtr);
  95.  
  96. void GetOrGeneratePrefs(PrefsType * thePrefsTypePtr, long versWantedLong, 
  97.     AliasHandle * fileAliasHandlePtr);
  98. OSErr SavePrefs(PrefsType * thePrefsTypePtr, AliasHandle * fileAliasHandlePtr);
  99.  
  100. void SetPrefRadioButton(DialogPtr prefDialogPtr, short buttonItemNum,Boolean setFlag);
  101. void SetPrefRadioButtonTrio(DialogPtr prefDialogPtr, short item);
  102. void SetPrefText(DialogPtr prefDialogPtr, short textItemNum, Str255 setStr);
  103.  
  104. OSErr GetPrefsName(Str255 prefName);
  105.  
  106. /*
  107.  *
  108.  *   main program
  109.  *
  110.  */
  111.  
  112. void main () 
  113. {
  114.     PrefsType currPrefs;                  /* prefs structure  */
  115.     AliasHandle fileAliasHandle = nil;    /* "preferred" file */
  116.  
  117.     Boolean prefsChangedFlag;
  118.     
  119.     long gestAliasResponse, gestStdFileResponse, gestFSResponse;
  120.     short tempResRefNum;
  121.     Str255 errStr;
  122.     OSErr retCode;
  123.     
  124.     /* standard toolbox initialization */
  125.     InitGraf(&qd.thePort);
  126.     InitFonts();
  127.     InitWindows();
  128.     InitMenus();
  129.     TEInit();
  130.     InitDialogs(nil);
  131.     InitCursor();
  132.     
  133.     /* Ensure that appropriate facilities are available so I don't crash
  134.     
  135.        Think & MPW glue handles calls to Gestalt and FindFolder under 6.x so
  136.        those are always available, but the Alias Manager, new Standard File,
  137.        and FSSpecs must be present as indicated by Gestalt */
  138.     
  139.     retCode = Gestalt(gestaltAliasMgrAttr, &gestAliasResponse);
  140.     if (retCode == noErr) retCode = Gestalt(gestaltFSAttr, &gestFSResponse);
  141.     if (retCode == noErr)
  142.         retCode = Gestalt(gestaltStandardFileAttr, &gestStdFileResponse);
  143.     
  144.     if (retCode != noErr ||
  145.         (gestAliasResponse & (1 << gestaltAliasMgrPresent)) == 0 ||
  146.         (gestFSResponse & (1 << gestaltHasFSSpecCalls)) == 0 ||
  147.         (gestStdFileResponse & (1 << gestaltStandardFile58)) == 0) {
  148.     
  149.         /* display a dialog saying System 7 is needed, then bail out */
  150.         
  151.         GetIndString(errStr, kErrorStrListID, kSystem7NeededStrIndex);
  152.         ParamText(errStr, nil, nil, nil);
  153.         (void) StopAlert(kGeneralAlertID, nil);
  154.         ExitToShell();
  155.     }
  156.         
  157.     /* if there is no preference file already, display the introductory dialog   */
  158.     
  159.     /* this is a bit lazy: it just tries to open the file, and if that succeeds,
  160.      * the file is immediately closed                                           
  161.      */
  162.     
  163.     tempResRefNum = OpenPrefsResFile(fsRdPerm, false);
  164.     
  165.     if (tempResRefNum == -1)
  166.         (void) Alert(kIntroAlertID, NewModalFilterProc( nil )); /* intro dialog */
  167.     else CloseResFile(tempResRefNum);
  168.         
  169.         
  170.     /* Three steps for the preferences dialog:
  171.      * - get the old preference settings from the prefs file,
  172.      *   or fill in the prefs record with defaults
  173.      * - display the dialog
  174.      * - if the user made changes, save the new preferences
  175.      */
  176.      
  177.     GetOrGeneratePrefs(&currPrefs, kCurrentPrefsTypeVers, &fileAliasHandle);
  178.     
  179.     prefsChangedFlag = DoPrefsDialog(&currPrefs, &fileAliasHandle);
  180.     
  181.     if (prefsChangedFlag) retCode = SavePrefs(&currPrefs, &fileAliasHandle);
  182. }
  183.  
  184.  
  185. Boolean DoPrefsDialog(PrefsType * thePrefsTypePtr, AliasHandle * fileAliasHandlePtr)
  186. /* display the prefs dialog; returns true if change made to prefs record */
  187. {
  188.     GrafPtr savePort;
  189.     DialogPtr prefDialogPtr;
  190.     short item;
  191.     Boolean doneFlag = false;
  192.     OSErr retCode;
  193.  
  194.     /* keep the new preference settings only in local variables
  195.        in case the user cancels */
  196.        
  197.     PrefsType newPrefsType;
  198.     AliasHandle newFileAliasHandle;
  199.  
  200.     StandardFileReply mySFR;
  201.     SFTypeList mySFTypeList;
  202.  
  203.     short itemType;
  204.     Handle itemHandle;
  205.     Rect itemRect;
  206.     
  207.     FSSpec tempFSSpec;
  208.     Boolean changedFlag;
  209.  
  210.  
  211.     /* the old settings are our starting point, so copy them */
  212.     newPrefsType = *thePrefsTypePtr;
  213.     newFileAliasHandle = *fileAliasHandlePtr;
  214.     
  215.     /* throw up the dialog */
  216.     prefDialogPtr = GetNewDialog(kPrefsDialogID, nil, (WindowPtr) -1);
  217.     if (prefDialogPtr == nil) ExitToShell();  /* hurtin’ bad */
  218.     
  219.     /* set up the dialog to the initial values */
  220.     SetPrefRadioButtonTrio(prefDialogPtr, thePrefsTypePtr->rButtonShort);
  221.     SetPrefText(prefDialogPtr, kEditTextItem, thePrefsTypePtr->editStr);
  222.     SelectDialogItemText(prefDialogPtr, kEditTextItem, 0, 32767);
  223.     
  224.     /* set the initial file name by resolving the alias */
  225.     retCode = ResolveAlias(nil, newFileAliasHandle, &tempFSSpec, &changedFlag);
  226.     if (retCode == noErr)
  227.         SetPrefText(prefDialogPtr, kSelectStatTextItem, tempFSSpec.name);
  228.     else SetPrefText(prefDialogPtr, kSelectStatTextItem, "\p");
  229.     
  230.  
  231.     do {
  232.         GetPort(&savePort);
  233.         SetPort(prefDialogPtr);
  234.         ModalDialog(nil, &item);
  235.         switch(item) {
  236.         
  237.             case kSaveButtonItem:
  238.                 /* user wants to save the current or new settings */
  239.                 
  240.                 /* copy the editText string into the new prefs record */
  241.                 GetDialogItem(prefDialogPtr, kEditTextItem, 
  242.                     &itemType, &itemHandle, &itemRect);
  243.                 GetDialogItemText(itemHandle, newPrefsType.editStr);
  244.                                 
  245.                 /* replace the old record with the new record */
  246.                 *thePrefsTypePtr = newPrefsType;
  247.                 
  248.                 /* if there is a new file alias, dispose of the old one and
  249.                    copy the new handle */
  250.                    
  251.                 if (*fileAliasHandlePtr != newFileAliasHandle) {
  252.                     if (*fileAliasHandlePtr != nil)
  253.                         DisposeHandle((Handle)  *fileAliasHandlePtr);
  254.                     *fileAliasHandlePtr = newFileAliasHandle;
  255.                 }
  256.                 doneFlag = true;
  257.                 break;
  258.                 
  259.             case kCancelButtonItem:
  260.                 /* abandon the new preferences structure */
  261.                 doneFlag = true;
  262.                 
  263.                 /* if an alias was allocated, dispose of it */
  264.                 if (newFileAliasHandle != *fileAliasHandlePtr &&
  265.                     newFileAliasHandle != nil)
  266.                     DisposeHandle((Handle) newFileAliasHandle);
  267.                 break;
  268.                 
  269.             case kHighRButtonItem:
  270.             case kMediumRButtonItem:
  271.             case kLowRButtonItem:
  272.                 /* handle a radio button click */
  273.                 SetPrefRadioButtonTrio(prefDialogPtr, item);
  274.                 newPrefsType.rButtonShort = item;
  275.                 break;
  276.                 
  277.             case kSelectButtonItem:
  278.                 /* select a file the usual way */
  279.                 StandardGetFile(nil, -1, mySFTypeList, &mySFR);
  280.                 
  281.                 if (mySFR.sfGood) {
  282.                 
  283.                     /* make an alias to the selected file */
  284.                     
  285.                     newPrefsType.fileAliasID = kFileAliasResourceID;
  286.  
  287.                     /* if an alias was allocated, dispose of it */
  288.                     if (newFileAliasHandle != *fileAliasHandlePtr &&
  289.                         newFileAliasHandle != nil)
  290.                         DisposeHandle((Handle) newFileAliasHandle);
  291.  
  292.                     retCode = NewAlias(nil, &mySFR.sfFile, &newFileAliasHandle);
  293.                     
  294.                     if (retCode != noErr) {
  295.                         /* really should display a warning or something */
  296.                         SysBeep(10);
  297.                         newFileAliasHandle = nil;
  298.                         *mySFR.sfFile.name = 0;
  299.                         newPrefsType.fileAliasID = kNoAliasResourceID;
  300.                     }
  301.                     
  302.                     /* display the selected file's name in the dialog */
  303.                     
  304.                     SetPrefText(prefDialogPtr, kSelectStatTextItem, mySFR.sfFile.name);
  305.                 }
  306.         }
  307.     } while (!doneFlag);
  308.     
  309.     DisposeDialog(prefDialogPtr);
  310.     
  311.     SetPort(savePort);
  312.  
  313.     /* if the user clicked Save, return true */
  314.     return (item == kSaveButtonItem);
  315. }
  316.  
  317. void SetPrefRadioButtonTrio(DialogPtr prefDialogPtr, short item)
  318. /* set one radio button item in the prefs dialog, clear the others */
  319. {
  320.     SetPrefRadioButton(prefDialogPtr, kLowRButtonItem,(item == kLowRButtonItem));
  321.     SetPrefRadioButton(prefDialogPtr, kMediumRButtonItem,(item == kMediumRButtonItem));
  322.     SetPrefRadioButton(prefDialogPtr, kHighRButtonItem,(item == kHighRButtonItem));                 
  323. }
  324.  
  325. void SetPrefRadioButton(DialogPtr prefDialogPtr, short buttonItemNum, Boolean setFlag)
  326. /* set radio button number buttonItemNum in the prefs dialog if setFlag is true */
  327. {
  328.     short itemType;
  329.     Handle itemHandle;
  330.     Rect itemRect;
  331.  
  332.     GetDialogItem(prefDialogPtr, buttonItemNum, &itemType, &itemHandle, &itemRect);
  333.     SetControlValue((ControlHandle) itemHandle, (setFlag ? 1 : 0));
  334. }
  335.  
  336. void SetPrefText(DialogPtr prefDialogPtr, short textItemNum, Str255 setStr)
  337. /* set the text item in the dialog to setStr */
  338. {
  339.     short itemType;
  340.     Handle itemHandle;
  341.     Rect itemRect;
  342.  
  343.     GetDialogItem(prefDialogPtr, textItemNum, &itemType, &itemHandle, &itemRect);
  344.     SetDialogItemText(itemHandle, setStr);
  345. }
  346.  
  347.  
  348. void GetOrGeneratePrefs(PrefsType * thePrefsTypePtr, long wantedVers,
  349.     AliasHandle * fileAliasHandlePtr)
  350. /* fill in the prefs structure from the resource file or from scratch */
  351. {
  352.     short prefsResRefNum;
  353.     Handle tempHandle;
  354.     
  355.     Str255 defaultStr = "\pDefault Edit Text";
  356.     
  357.     /* initialize prefs structure in case we can't get a valid set */
  358.     thePrefsTypePtr->prefsTypeVers = kCurrentPrefsTypeVers;
  359.     thePrefsTypePtr->rButtonShort = kMediumRButtonItem;
  360.     thePrefsTypePtr->fileAliasID = kNoAliasResourceID;
  361.     BlockMove(defaultStr, thePrefsTypePtr->editStr, *defaultStr+1);
  362.     *fileAliasHandlePtr = nil;
  363.     
  364.     /* open (but don't create) the prefs file */
  365.     prefsResRefNum = OpenPrefsResFile(fsRdPerm, false);
  366.     if (prefsResRefNum != -1) {
  367.     
  368.         /* file opened successfully, get the prefs resource */
  369.         tempHandle = Get1Resource(kPrefsResourceType, kPrefsResourceID);
  370.         
  371.         /* if the resource is there and it's the right size and version, copy it */
  372.         /* (in C these can be combined with &&, but don't use AND in Pascal)     */
  373.         
  374.         if (tempHandle != nil)
  375.             if (GetHandleSize(tempHandle) == sizeof(PrefsType)) 
  376.                 if ((*(PrefsType *)*tempHandle).prefsTypeVers == wantedVers) {
  377.                 
  378.                     /* copy the prefs struct */
  379.                     *thePrefsTypePtr = *(PrefsType *)*tempHandle;
  380.                     
  381.                     /* if there's also an alias, get and detach that, too */
  382.                     if (thePrefsTypePtr->fileAliasID != kNoAliasResourceID) {
  383.                     
  384.                         /* don't orphan a previous alias handle */
  385.                         if (*fileAliasHandlePtr != nil)
  386.                             DisposeHandle((Handle) *fileAliasHandlePtr);
  387.                             
  388.                         *fileAliasHandlePtr = (AliasHandle)
  389.                             Get1Resource(rAliasType, thePrefsTypePtr->fileAliasID);
  390.                         
  391.                         if (*fileAliasHandlePtr != nil)
  392.                             DetachResource((Handle) *fileAliasHandlePtr);
  393.                     }
  394.                 }
  395.         /* release the pref resource and close the file */
  396.         CloseResFile(prefsResRefNum);
  397.     }
  398. }
  399.  
  400. OSErr SavePrefs(PrefsType * thePrefsTypePtr, AliasHandle * fileAliasHandlePtr)
  401. /* save the prefs structure in the prefs resource file */
  402. {
  403.     OSErr retCode;
  404.     short prefsResRefNum;
  405.     Handle prefHandle, alisHandle, finderMessageHandle;
  406.     
  407.     /* open (and, if necessary, create) the prefs file */
  408.     prefsResRefNum = OpenPrefsResFile(fsRdWrPerm, true);
  409.     if (prefsResRefNum != -1) {
  410.     
  411.         /* file opened successfully, get the prefs resource */
  412.         prefHandle = Get1Resource(kPrefsResourceType, kPrefsResourceID);
  413.         
  414.         if (prefHandle == nil) {
  415.         
  416.             /* create a new resource */
  417.             prefHandle = NewHandle(sizeof(PrefsType));
  418.             if (prefHandle != nil) {
  419.             
  420.                 /* copy the prefs struct into the handle
  421.                    and make it into a resource */
  422.                 
  423.                 *(PrefsType *)*prefHandle = *thePrefsTypePtr;
  424.                 AddResource(prefHandle, kPrefsResourceType, kPrefsResourceID, 
  425.                     "\pPrefsType");
  426.                 retCode = ResError();
  427.                 if (retCode != noErr) DisposeHandle(prefHandle);
  428.             } 
  429.             
  430.             else retCode = MemError(); /* NewHandle failed */
  431.         }
  432.         
  433.         else {  /* prefHandle != nil */
  434.         
  435.             /* update the existing resource */
  436.             SetHandleSize(prefHandle, sizeof(PrefsType));
  437.             retCode = MemError();
  438.             if (retCode == noErr) {
  439.  
  440.                 /* copy the prefs struct into the handle and tell the rsrc manager */
  441.                 *(PrefsType *)*prefHandle = *thePrefsTypePtr;
  442.                 ChangedResource(prefHandle);
  443.             }
  444.         }
  445.         
  446.         if (retCode == noErr) {
  447.             /* now, get rid of the old fileAlias and, if the fileAliasID field
  448.                of the prefs struct indicates that there is a new one, add it to
  449.                the resource file */
  450.                
  451.             /* remove any old file alias */
  452.             alisHandle = Get1Resource(rAliasType, thePrefsTypePtr->fileAliasID);
  453.             if (alisHandle != nil) {
  454.                 RemoveResource(alisHandle);
  455.                 DisposeHandle(alisHandle);
  456.             }
  457.             
  458.             /* if appropriate, add the current alias to the resource file */
  459.             
  460.             if (thePrefsTypePtr->fileAliasID != kNoAliasResourceID &&
  461.                 *fileAliasHandlePtr != nil) {
  462.                 
  463.                 AddResource((Handle) *fileAliasHandlePtr, rAliasType, 
  464.                     thePrefsTypePtr->fileAliasID, "\pfile alias");
  465.                     
  466.                 /* keep the alias available */
  467.                 DetachResource((Handle) *fileAliasHandlePtr);
  468.             }
  469.             
  470.             /* add the message to be displayed if the user tries
  471.                to open the prefs file in the Finder (but don't add it
  472.                if it's already in the preferences file) */
  473.                
  474.             finderMessageHandle = (Handle) GetString(kFinderMessageStrID);
  475.             if (finderMessageHandle != nil &&
  476.                 HomeResFile((Handle) finderMessageHandle) != prefsResRefNum) {
  477.             
  478.                 /* copy the resource into the prefs file */
  479.                 DetachResource(finderMessageHandle);
  480.                 AddResource(finderMessageHandle, kStrType, kFinderMessageStrID,
  481.                     "\pFinder message");
  482.                     
  483.                 /* if AddResource failed, dispose of the handle */
  484.                 retCode = ResError();
  485.                 if (retCode != noErr) DisposeHandle(finderMessageHandle);
  486.             }
  487.         }
  488.         
  489.         /* update and close the preference resource file, 
  490.            releasing its resources from memory */
  491.         CloseResFile(prefsResRefNum);
  492.     }
  493.     
  494.     else {
  495.         /* couldn't open the res file */
  496.         retCode = ResError();
  497.         if (retCode == noErr) retCode = resFNotFound;
  498.     }
  499.     
  500.     return retCode;
  501. }
  502.  
  503. short OpenPrefsResFile(SignedByte prefsPerm, Boolean createFlag)
  504. /* open the preferences file with the given permission; if createFlag is set,
  505.    create a preferences file if necessary */
  506. {
  507.     OSErr retCode;
  508.     short prefsVRefNum;
  509.     long prefsDirID;
  510.     Str255 prefsNameStr;
  511.     FSSpec prefsFSSpec;
  512.     short prefsResRefNum = -1;
  513.     
  514.     /* get the name of the prefs file */
  515.     retCode = GetPrefsName(prefsNameStr);
  516.     if (retCode == noErr) {
  517.     
  518.         /* Use FindFolder to locate the Preferences folder.
  519.         
  520.            MPW 3.2 and some other compilers provide the
  521.            glue necessary to use FindFolder (and Gestalt) safely
  522.            under System 6 and earlier.  Under System 6, the dirID
  523.            returned for the Preferences folder request will be
  524.            the System folder's dirID */
  525.  
  526.         retCode = FindFolder(kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
  527.             &prefsVRefNum, &prefsDirID);
  528.         if (retCode == noErr) {
  529.         
  530.             /* make a file spec for the prefs file */
  531.             
  532.             retCode = FSMakeFSSpec(prefsVRefNum, prefsDirID, prefsNameStr,
  533.                 &prefsFSSpec);
  534.                 
  535.             if (retCode == fnfErr && createFlag) {
  536.                 /* prefs file doesn't already exist, so create it */
  537.                 FSpCreateResFile(&prefsFSSpec, kPrefsCreatorType, kPrefsFileType,
  538.                     smSystemScript);
  539.                 retCode = ResError();
  540.             }
  541.             
  542.             /* open the prefs file */
  543.             if (retCode == noErr) {
  544.                 prefsResRefNum = FSpOpenResFile(&prefsFSSpec, prefsPerm);
  545.             }
  546.         }
  547.     }
  548.     return prefsResRefNum;
  549. }
  550.  
  551. OSErr GetPrefsName (StringPtr prefName)
  552. /* get the name of the preferences file from a resource in the application */
  553. {
  554.     StringHandle prefStrHandle;
  555.     OSErr retCode = noErr;
  556.     
  557.     prefStrHandle = GetString(kPrefsNameStrID);
  558.     if (prefStrHandle != nil) 
  559.         BlockMove(*prefStrHandle, prefName, (Size) (**prefStrHandle) + 1);
  560.     else retCode = resNotFound;
  561.     
  562.     return retCode;
  563. }